package com.jg.utils.Thread;

import java.util.concurrent.TimeUnit;

public class ThreadApi {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());

        try {
//               test1();
//test3();

//               test4();
//               test5();
//               test6();
//               test7();
        } catch (Exception e) {

        }

    }

    /**
     * sleep方法是Thread类里的一个静态方法，有两个重载方法，一个需要传入毫秒数，一个需要传入毫秒
     * 数和纳秒数。
     * sleep方法会使当前线程进入休眠，虽然给定了一个毫秒数，但是具体休眠多久是根据系统的定时器的
     * 调度器的精度为准，一般不会有太大误差。
     * sleep进行休眠，线程是不会释放锁的（这个我们后面再讨论）
     *
     * @throws InterruptedException
     */
    public static void test1() throws InterruptedException {
        System.out.println("线程停次前");
        Thread.sleep(1000);
        System.out.println("线程结束");
    }

    /**
     * 用TimeUnit代替sleep
     * 在JDK1.5之后，JDK引入了一个枚举 TimeUnit ，想必这个枚举大家在很多地方都用过了。其对sleep方
     * 法也提供了很好的封装。使用它可以省去时间单位的换算 ，比如想让线程休眠 3 小时 24 分钟 17 秒 88
     * 毫秒。
     *
     * @param args
     * @throws InterruptedException
     */
    public static void test2(String[] args) throws InterruptedException {
        System.out.println("休眠前");
        TimeUnit.HOURS.sleep(3);
        TimeUnit.MINUTES.sleep(24);
        TimeUnit.SECONDS.sleep(17);
        TimeUnit.MILLISECONDS.sleep(88);
        System.out.println("休眠后");
    }

    /**
     * Thread类的 getId 方法是用来获取该线程的ID的，
     * 线程的ID在整个JVM进程中都会是唯一的，并且是
     * 从0开始递增。
     */
    public static void test3() {
        Thread thre = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("1111");
            }
        });
        long id1 = thre.getId();
        System.out.println("当前线程id:" + id1);
        thre.start();
        long id2 = thre.getId();
        System.out.println("当前线程id:" + id2);
//        获取当前线程
        Thread thread = Thread.currentThread();
        long id = thread.getId();
        System.out.println("当前线程id:" + id);

    }

    /**
     * interrupt
     * 当线程处于阻塞状态时（如调用sleep方法），
     * 如果有其他线程调用了该线程的 interrupt 方法，就
     * 可以打断阻塞，这种存在阻塞状态的方法有时候也称可中断方法。
     * 打断一个线程并不代表该线程的生命
     * 周期结束，仅仅是打断了阻塞状态。
     * 一个线程阻塞状态被打断，会跑出一个 InterruptedException ，这个异常就像是一个信号一样通知
     * 当前线程被打断了。
     *
     * @throws InterruptedException
     */
    public static void test4() throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        System.out.println("开始休眠");
                        TimeUnit.MINUTES.sleep(1);
                        System.out.println("线程休眠结束");
                    }


                } catch (Exception e) {
                    System.out.println("线程休眠被打断了");
                }
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(5);
//查看状态
        System.out.println(thread.isInterrupted());
        //打断阻塞
        thread.interrupt();
        System.out.println(thread.isInterrupted());
    }

    /**
     * interrupt
     * 当线程处于阻塞状态时（如调用sleep方法），
     * 如果有其他线程调用了该线程的 interrupt 方法，
     * 就可以打断阻塞，这种存在阻塞状态的方法有时候也称可中断方法。
     * 打断一个线程并不代表该线程的生命周期结束，
     * 仅仅是打断了阻塞状态。
     * 一个线程阻塞状态被打断，
     * 会跑出一个 InterruptedException ，
     * 这个异常就像是一个信号一样通知当前线程被打断了。
     */
    public static void test5() throws InterruptedException {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {

                    System.out.println("kaishi");
                }
            }
        });
        thread.start();

        TimeUnit.SECONDS.sleep(5);
        System.out.println(thread.isInterrupted());
        //打断阻塞
        thread.interrupt();
        TimeUnit.SECONDS.sleep(2);
        System.out.println(thread.isInterrupted());
        System.out.println(thread.isInterrupted());
        System.out.println(thread.isInterrupted());

    }

    /**
     * interrupted
     * interrupted 方法是Thread的一个静态方法，
     * 该方法的作用虽然也是判断当前线程是否中断，但是当该方法调用后，
     * 会直接擦除掉线程的中断标识。
     */
    public static void test6() throws InterruptedException {


        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    boolean flag = Thread.interrupted();
                    if (flag) {
                        System.out.println("获取结果为true");
                    }
                }
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(5);
        thread.interrupt();


    }
}
